// 版权所有2009年围棋作者。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package noder

import (
	"fmt"
	"internal/buildcfg"
	"strings"

	"cmd/compile/internal/ir"
	"cmd/compile/internal/syntax"
)

func isSpace(c rune) bool {
	return c == ' ' || c == '\t' || c == '\n' || c == '\r'
}

func isQuoted(s string) bool {
	return len(s) >= 2 && s[0] == '"' && s[len(s)-1] == '"'
}

const (
	funcPragmas = ir.Nointerface |
		ir.Noescape |
		ir.Norace |
		ir.Nosplit |
		ir.Noinline |
		ir.NoCheckPtr |
		ir.RegisterParams | // TODO（寄存器参数）在寄存器abi工作后删除
		ir.CgoUnsafeArgs |
		ir.UintptrEscapes |
		ir.Systemstack |
		ir.Nowritebarrier |
		ir.Nowritebarrierrec |
		ir.Yeswritebarrierrec

	typePragmas = ir.NotInHeap
)

func pragmaFlag(verb string) ir.PragmaFlag {
	switch verb {
	case "go:build":
		return ir.GoBuildPragma
	case "go:nointerface":
		if buildcfg.Experiment.FieldTrack {
			return ir.Nointerface
		}
	case "go:noescape":
		return ir.Noescape
	case "go:norace":
		return ir.Norace
	case "go:nosplit":
		return ir.Nosplit | ir.NoCheckPtr // 意味着无需检查KPTR（见#34972）
	case "go:noinline":
		return ir.Noinline
	case "go:nocheckptr":
		return ir.NoCheckPtr
	case "go:systemstack":
		return ir.Systemstack
	case "go:nowritebarrier":
		return ir.Nowritebarrier
	case "go:nowritebarrierrec":
		return ir.Nowritebarrierrec | ir.Nowritebarrier // 这意味着没有任何障碍
	case "go:yeswritebarrierrec":
		return ir.Yeswritebarrierrec
	case "go:cgo_unsafe_args":
		return ir.CgoUnsafeArgs | ir.NoCheckPtr // 意味着无需检查KPTR（见#34968）
	case "go:uintptrescapes":
		// 用于文件中声明的下一个函数
		// 任何uintptr参数都可以是指针值
		// 转换为uintptr。本指令
		// 确保已分配引用的
		// 对象（如果有）将被保留而不移动
		// 直到调用完成，即使从
		// 仅就类型而言
		// 在测试过程中不再需要对象
		// 呼叫必须显示到uintptr的转换
		// 在参数列表中。
		// 在syscall/dll\u windows.go中使用。
		return ir.UintptrEscapes
	case "go:registerparams": // TODO（寄存器参数）在寄存器abi工作后删除
		return ir.RegisterParams
	case "go:notinheap":
		return ir.NotInHeap
	}
	return 0
}

// 如果同时解析文件，则会同时调用pragcgo。
func (p *noder) pragcgo(pos syntax.Pos, text string) {
	f := pragmaFields(text)

	verb := strings.TrimPrefix(f[0], "go:")
	f[0] = verb

	switch verb {
	case "cgo_export_static", "cgo_export_dynamic":
		switch {
		case len(f) == 2 && !isQuoted(f[1]):
		case len(f) == 3 && !isQuoted(f[1]) && !isQuoted(f[2]):
		default:
			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf(`usage: // 转到：%s本地[远程]`，动词）}）
			return
		}
	case "cgo_import_dynamic":
		switch {
		case len(f) == 2 && !isQuoted(f[1]):
		case len(f) == 3 && !isQuoted(f[1]) && !isQuoted(f[2]):
		case len(f) == 4 && !isQuoted(f[1]) && !isQuoted(f[2]) && isQuoted(f[3]):
			f[3] = strings.Trim(f[3], `"`)
			if buildcfg.GOOS == "aix" && f[3] != "" {
				// 在Aix上，库模式必须是“lib.a/object.o”
				// 或“lib.a/libname.so.X”
				n := strings.Split(f[3], "/")
				if len(n) != 2 || !strings.HasSuffix(n[0], ".a") || (!strings.HasSuffix(n[1], ".o") && !strings.Contains(n[1], ".so.")) {
					p.error(syntax.Error{Pos: pos, Msg: `usage: // go:cgo_import_dynamic local[remote[“lib.a/object.o”]`}
					return
				}
			}
		default:
			p.error(syntax.Error{Pos: pos, Msg: `usage: // go:cgo_import_dynamic local[remote[“library”]`}
			return
		}
	case "cgo_import_static":
		switch {
		case len(f) == 2 && !isQuoted(f[1]):
		default:
			p.error(syntax.Error{Pos: pos, Msg: `usage: // go:cgo\u导入\u静态本地`}）
			return
		}
	case "cgo_dynamic_linker":
		switch {
		case len(f) == 2 && isQuoted(f[1]):
			f[1] = strings.Trim(f[1], `"`)
		default:
			p.error(syntax.Error{Pos: pos, Msg: `usage: // go:cgo_动态_链接器“路径”`}）
			return
		}
	case "cgo_ldflag":
		switch {
		case len(f) == 2 && isQuoted(f[1]):
			f[1] = strings.Trim(f[1], `"`)
		default:
			p.error(syntax.Error{Pos: pos, Msg: `usage: // go:cgo_ldflag“arg”`}）
			return
		}
	default:
		return
	}
	p.pragcgobuf = append(p.pragcgobuf, f)
}

// pragmaFields类似于strings.FieldsFunc（s，isSpace）
// 但在双引号区域内不拆分，并且始终
// 在双引号区域的开始和结束之前分割。
// pragmaFields不识别转义引号。如果s中的报价不正确
// 在开始报价后关闭的零件将不会作为字段返回。
func pragmaFields(s string) []string {
	var a []string
	inQuote := false
	fieldStart := -1 // 查找字段开头时设置为-1。
	for i, c := range s {
		switch {
		case c == '"':
			if inQuote {
				inQuote = false
				a = append(a, s[fieldStart:i+1])
				fieldStart = -1
			} else {
				inQuote = true
				if fieldStart >= 0 {
					a = append(a, s[fieldStart:i])
				}
				fieldStart = i
			}
		case !inQuote && isSpace(c):
			if fieldStart >= 0 {
				a = append(a, s[fieldStart:i])
				fieldStart = -1
			}
		default:
			if fieldStart == -1 {
				fieldStart = i
			}
		}
	}
	if !inQuote && fieldStart >= 0 { // 最后一个字段可能以字符串结尾。
		a = append(a, s[fieldStart:])
	}
	return a
}
